White Dots in Output (I don't think they are normal fireflies—but could be wrong)

[imauserwiththisname (Mitch)]

Hi all,

Working on a few design concept renderings for a client and 2 of the 5 files output had these larger well-defined random round white dots that didn’t show up in the live view or live output window, just the output files.

Don’t mind the normal fireflies, those get sorted out in post, but I thought it was worth checking to see if anyone else is experiencing these larger well-defined artifacts as this is the first time I am getting them. I have had the black square issue with GPU rendering a ways back, but this seems different.

My setup is as follows:

• KeyShot Studio 2025.1.1
• CPU Rendering → AMD Ryzen Threadripper PRO 3955WX 16-Cores
• Max samples → 128 Samples
• Resolution → 3840 x 2160
• Format → PSD 16-Bit
• Ray Bounces → 6
• GI Bounces → 1
• Caustics → On
• Rendering Technique → Product Mode
• Denoise → 0.05
• Firefly Filter → 0.2

Lighting setup below:

Finally, here is the other output that had the random white dots in it, this is after some healing but before taking care of all the fireflies. Let me know if you notice anything consistent about these two that I am overlooking by chance:

Would appreciate some insights on how to prevent these pesky random white dot artifacts.

Thank you!
M

[oscar.rottink]

Hi Mitch,

I guess it’s caustics which causes them to appear. In this scene I don’t think caustics adds anything so I would disable caustics.

When I was testing with an interior render I noticed it helps a lot to push more light in the scene. It makes it way easier for the renderer to get a nice result with less noise. I think your light comes from a spot light but I would replace it with area lights or planar lights. If I look at other interior scenes for other renderers most of the time they put an area light on every window.

On interior scenes I would also increase the GI bounces since that helps to get light in corners and will also make the entire scene lighter. It’s way easier to make it darker in post than lighter.

I only use GPU to render but if you want to share the scene so I can try a render you can send me a private message and I’ll give it a go.

[imauserwiththisname (Mitch)]

Hi @oscar.rottink,

Thank you for your response as always!

You’re right, caustics doesn’t make sense here as the light source isn’t focused enough and glass rondels don’t exactly benefit from caustics to begin with. My late night brain defaulted to glass = caustics on.

I generally follow the approach you mentioned for area lights on windows and boosting the GI bounces up when I add a ceiling and more than one wall, otherwise the shadows are often blotchy. I was testing out this approach with just a back wall and an open HDRI environment (with lower brightness) utilizing the new ‘add light’ tool in KS25 to get set up quickly and it was a nice experience!

I’m wondering what the correct use is for spot lights as I often read conflicting opinions and see them used in certain ways that I might not be fully understanding.

I’ll run these again without caustics, revised light types, and higher GI bounces to see where it lands and get in touch via private message if I experience a similar result.

Thanks again,
M

[oscar.rottink]

Hi Mitch,

I use spotlights where I would use them as well in reality. Like spots in a ceiling which have a fixture which concentrates a beam or like those halogen spotlights which often have their own reflector which give them a certain angle.

Not saying you can’t switch them around if it gives a better result. And you’re currently have an interior render so spotlights are pretty common.

The image below was an interior scene I was working on, still not finished but I just wanted to try how KeyShot handles those scenes. And I really pushed a lot of light in from the windows which gives the advantage you get less noise but also lower render times.

If I recall correctly, I also put the exposure slider under image a bit higher.

[imauserwiththisname (Mitch)]

Hi Oscar,

That makes sense! I recognize your shelf design in that rendering you are working on!
Definitely appears to be pulling in lots of light via the windows, so it seems to be a good approach.

I re-output without caustics and the dots are gone, so you were indeed correct. Thank you for taking the time to make the suggestion.

I’m going to try a version without the spotlight to see if I can minimize the firefly removal in post.

Best,
M

[don.tuttle]

Hey Mitch, I see you got it worked out, but I wanted to mention that increasing the size of the spotlight often introduces the fireflies. When lighting scenes I use physical lights with purpose for the reason I mentioned previously.

Often, for interiors I will use the Image Styles Curves to enhance the lighting. For example, I’ll have images styles with curves adjusted for morning, afternoon, and night lighting.

[oscar.rottink]

Hey Don,

Would be nice if KeyShot got better with physical lights introducing fireflies. Or it should ‘simply’ avoid them since often they are over bright pixels with different surrounding pixels. The firefly filter can also be improved a lot.

Think that’s one of the main reasons I wouldn’t use KeyShot for interior renders together with the fact that Keyshot lacks nice tricks to keep the VRAM usage under control. With a lot of textures in an interior you run out of VRAM fast. Hope they will take a look on how smart V-Ray handles such scenes. Like for example dynamically resizing textures if they are further away from camera.

[don.tuttle]

You’re right that fireflies can be a challenge, especially in interior renders with physical lights. But I wouldn’t throw physical lights out the window just yet they’re critical for achieving realism if handled intentionally.

From the OP’s screenshot, my first instinct was also the spotlight size, it plays a huge role in light sampling quality. A very large emitter or spotlight often causes fireflies due to high intensity rays not getting enough sample coverage. Decreasing the light source size or adjusting its intensity and falloff can help here.

Also worth noting, bump maps , specular roughness , and caustic-reflective surfaces can all be culprits. These can introduce unpredictable high-frequency noise, which then manifests as fireflies. If you’re using things like tiny metal flakes or extreme roughness/IOR settings, that’s another area to investigate.

I totally agree with using physical lights with purpose , they’re invaluable for things like defining shadow shape, simulating light fixtures, emphasizing geometry, and producing caustics where an HDRI alone falls short. I often pair a physical area light with HDRI just to accent shadows or drive reflections.

On filtering:

• Firefly filter : I start around 0.05 and rarely exceed 0.1 , as higher values tend to blur out specular details.
• Denoiser : I consider it a last resort, great for drafts or fast looks, but if I’m delivering final-quality imagery, I aim to clean up noise with better light/material setup or sample tuning first.

Lastly, on the VRAM topic, KeyShot will use all your RAM if you’re running out of texture memory, additional RAM would help. LOD support would be cool, but if you think it’s a necessity, I’d be curious to know more about the texture sizes and file types you’re using. That might help identify other optimizations or patterns worth discussing.

These aren’t hard rules, just hard-earned battle scars. I hope that helps others troubleshoot similar issues.

[oscar.rottink]

Thanks @don.tuttle! Really love to hear a bit more about the technical part and from your experiences. I know KeyShot is aiming at user friendly which I think is excellent but often I miss some in depth information on how KeyShot handles certain things behind it’s interface. And while the manual is explaining things in a very friendly way as well there is very little inside the manual to get an idea on how to troubleshoot specific issues you can encounter. Often some background information is also needed.

Like for example the number of samples you can fill in on certain materials, I’ve never noticed any difference changing that value if I thought for example a light needed more samples, it just doesn’t seem to make a difference. In my PDF with some suggestions about KS I actually did the suggestion to remove it since I don’t see a difference at all. Which might be caused by the fact I use GPU only to render scenes but for me it’s a kind of placebo slider.

The denoiser in KeyShot is quite agressive I think especially when you need to render materials with a fine structure. I’m also not sure what denoiser is used, I guess the Nvidia one. In V-Ray you can pick between 3, Intel, V-Ray and the Nvidia one. Depending on what you render every denoiser has it’s pro/cons. Being able to choose is nice. I often render quite simple materials and using the denoiser and also the sharpen filter gives a nice quick result and saves a lot off render time, as said, really depends on the materials.

I’m curious about the RAM since I think KS just crashes if I run over my available VRAM. Or well, the GPU driver crashes and it switches to CPU. Would be nice if it would use the normal RAM although it will slow things down but that’s not what I notice if I ate all VRAM because hungry

If you’ve one material in 4K in KS with a diffuse, roughness and normal map where last two are 16-bit the material will use 576MB of VRAM. That’s also because KS translates 16-bit images internally to 32-bit (which is already a bit of a waste of VRAM imo).

With an interior where you will do multiple renders you’ve many fabrics/woods etc and it really adds up. It’s not the geometry which is the issue but it’s the usage of textures. With interiors you might shoot some close-up shots, some more distant shots so it’s not that you can simply use 1K textures since you want all shots to look nice and in the example above I have 3 textures for one material, it could be more with more complicated materials like the need of a metallic texture.

And I know V-Ray has a different target audience, more in the archviz corner but the way it can handle VRAM would also benefit a lot of people using KeyShot who have a limited amount of VRAM available.

In V-Ray there are these options:

• resize all textures to a certain size, simple but not optimal
• dynamic mipmapping of textures, this is a clever one I think. It just considers the distance of objects from camera and uses the optimal mipmap needed for that distance.
• compressing textures so they stay the same pixel size but use less VRAM. This can reduce quality but looking at the example in the manual this could also help a lot in KS because those numbers are really high
• using system memory if needed, while it’s a great escape it will slow down renders pretty much but it’s nice it can be done.

Since more and more people render using GPU I think it would be a big help if KS would consider implementing such options as well. It will save people a lot of time they would otherwise spend optimizing images themselves or even make different image sets for the same scene on different resolutions.

Even leaving 16-bit images (for height/roughness/bump) just 16-bit would already help. For a long time I’ve trying to fix a test scene in both V-Ray and KS using same textures but it’s pretty time consuming so it’s still a work in progress.

[don.tuttle]

@oscar.rottink Right on! I was a V-ray user for years but always loved KeyShot for the simplicity and speed.

Samples Setting – GPU Ignores It

The material “samples” setting only affects CPU rendering . On GPU, it’s effectively a dead slider doesn’t influence quality or noise reduction. Probably makes sense to disable or hide it in GPU mode for clarity.

Denoiser

KeyShot uses Nvidia OptiX as its denoiser. It works well for general noise but can smear fine texture detail (especially fabric/bump maps). My go-to setup:

• Firefly Filter at 0.05
• Clean up noise at the material level (reduce bump depth, refine roughness/spec)
• Use denoise as a final polish, not a fix-all

V-Ray’s multi-denoiser system (Intel/V-Ray/Nvidia) is super useful, would love to see something similar in KS GPU mode

CPU vs. GPU Denoising – Dual Option in CPU Mode
In CPU mode, KeyShot supports both Intel and Nvidia denoising:

• The Smoothing option uses Intel Open Image Denoise
• The Denoise checkbox applies Nvidia OptiX
• You can use them together or separately

This combo can help clean up interiors with soft lighting and complex GI, but beware of over smoothing. GPU rendering only uses Nvidia OptiX — no Intel option there (yet).

VRAM Crash = Hardware, Not Software

This isn’t a KS problem per se, once your scene exceeds available GPU memory , the driver crashes or it swaps to CPU. Some renderers (like V-Ray) allow fallback to system RAM (at a performance cost), which would be a great “safety net” in KeyShot too.

Texture Optimization – Where the Real Bottleneck Is

8-bit textures are perfectly fine for 99% of what you’ll do in KeyShot. You won’t get any real gain from using 16-bit… Unless you’re displacing geometry or exporting 16-bit masks for compositing, using 16-bit textures in KeyShot is like filling a kiddie pool with Evian, expensive, unnecessary, and no one notices the difference.

As for resolution, follow a 1:1 rule: Match your texture resolution to your render resolution and go higher only if you’re doing close-ups or extreme detail work. You’ll save VRAM, boost performance, and avoid choking your GPU for no visual benefit.

Use Packed Maps (Yes, KeyShot Supports It!)

KeyShot does support packed maps you can extract individual channels (R, G, or B) using the Color to Number node in the Material Graph .

Example: Classic PBR Packed Map

If you’ve created a single texture like this:

• R = Metalness
• G = Roughness
• B = Ambient Occlusion

You can:

1. Load that single packed texture in KeyShot.
2. Drop a Color to Number node in the Material Graph.
3. Connect it to your texture and extract the R , G , or B channels.
4. Feed each channel to the appropriate material input (e.g., Roughness goes to Roughness, etc.).

Why use packed maps?

• Memory savings — One packed 4K map (~5–6MB PNG) replaces 3 separate 4K textures (~15–20MB).
• Easier to manage — Fewer files, tighter workflow, especially when using texture sets from tools like Substance Painter.
• Cleaner graphs — Reduces node clutter.

Just note that KeyShot doesn’t auto-unpack or auto-tag channels — you’ll need to manually connect them in the Material Graph or I can make a script.

Texture Resolution & Bit Depth Best Practices for KeyShot (and Honestly, Most Renderers)

8-bit is perfectly fine for 95% of use cases in KeyShot:

• Roughness, Metalness, AO, Opacity, and Bump maps don’t benefit from 16-bit in most workflows.
• Save VRAM and load time by sticking to 8-bit grayscale PNG or JPG , unless you’re doing real displacement or compositing passes.

Texture Resolution – Match the Render Context

A good general rule:

Your texture resolution should match your final render resolution — 1:1 texel to pixel wherever possible.

Render Use Case	Texture Resolution Recommendation
Full-scene render @ 1920×1080	2K texture (2048px) is more than enough
Close-up detail shots (product macro, fabrics, logos)	4K or 8K texture for that area only
Background props or far geometry	512px to 1K max

Per-case logic is key . Using 8K across an entire interior? Massive waste.
But zooming into a stitched logo on a shoe? That’s where high-res texture pays off.

Mipmapping – Probably Not Useful (Yet)

Mipmapping only helps if your renderer streams in textures based on distance (like Unreal or V-Ray). But KeyShot loads all textures into GPU memory at full res, so mipmapping by itself doesn’t lower VRAM usage. Without on-demand texture streaming? No real benefit.

Bonus Tip: Turn on the HUD

The in-scene HUD gives you live GPU memory usage great for diagnosing when you’re about to run out.

Note ChatGPT was used for formatting this post.*

[oscar.rottink]

Thanks for the great response! Same for me, V-Ray has some nice things but it’s far from friendly and it’s way quicker to get nice looking results in KeyShot for most purposes.

Some remarks/questions:

Image size

If it actually makes a difference if you load greyscale 8-bit and it also makes a difference if you use png or jpg than it would be nice if the manual would mention it. I’ve the feeling, but can be wrong, that KS only makes a difference between 8-bit and 16-bit and that they are all in one single format, but with different bit-depth, loaded into the GPU memory. I’m not sure if it’s the same with CPU renders but I only use GPU

Packed Images

Packed maps are really nice if you create your own textures, rendering interiors you mostly use props which are ready made and they rarely come with packed maps. Converting them would be very time consuming. Of course, you can create a script which uses ImageMagick to automate things, but you still have to reassign/change every single material. In an interior render that would really be a massive amount of work and doesn’t really fit the friendly KS environment.

Automatic scaling of images

The normal V-Ray GPU doesn’t stream textures as far as I know, V-Ray Vantage is another story, that will stream textures. I see that the option is actually removed currently from V-Ray. The way it works is that it just checks where a texture is used in the scene, calculates the needed resolution for that image, scales it down and sends it to the VRAM. I don’t actually think such a calculation is that hard since you can just calculate the amounts of pixels the object takes and how the texture is mapped around the object. It will slow down the start of a render a bit but with the speed of current GPUs I think such an option would be a welcome one for people who like to do more complex scenes using KS.

HUD

I’ve always enabled the HUD although I always get an itch by looking at the cut off numbers. And it would be really nice if the HUD got extended with a line with the actual used VRAM as well. Often people will have multiple programs open, for me it’s mostly Substance Painter + MODO + Photoshop and they all use VRAM. What KS often reports is a number between the VRAM used by KeyShot and the actual used VRAM by all software. Doesn’t have to be totally exact but it happens KS crashes because I focus too much on the number in the HUD while in reality quite a bit more VRAM is used.

I’m totally aware most people won’t render anything as complex as an interior using KS. Just with all stronger GPUs these days people also get more tempting to decorate their scenes a bit more without having to wait for hours to have them rendered. At least that’s how it works for me when I went from a 1070+1070 > 1070+2080Ti > 3090 > 3090+4090.

Thanks for the detailed reply again, it’s nice to know a bit more on how things like denoising work inside KS. The image sizes are still a bit of a mystery to me though, on how and in what format they are actually stored inside the VRAM. If for example JPGs would stay JPGs that would mean you can easily save some GBs of VRAM but I don’t think it works like that from experience.

[no AI was tortured for the layout, it was just me]

[don.tuttle]

Admittingly, I have not used V-ray in a decade, GPU rendering was added back then but I didn’t use it for production, and I do not remember if it had a denoiser.

Image Size
I know what you mean and I’m not sure about what’s going on under the hood. Thinking in terms of bast practices and what we do know for sure, file type has many differences on both CPU and GPU. You know this but, PNG with alpha vs a JPG vs a 32-bit EXR file. I’ve seen servers lock up from 32-bit EXR files. Changed to PNG no issues slight fidelity differences. Only detectable by experts like us.

Packed images
Totally get it BUT have you tried exporting the assets from KeyShot as a glTF? KeyShot will bake and pack the textures. Understandably who wants to go and re-export perfectively good models just to get the file size smaller? Not me, but it’s an option!

The way you describe the texture scaling sounds really useful. I mean yeah, if the texture isn’t visible why even load it?! Super cool!

My pleasure and likewise thanks for contributing.

[calvin.henderson]

Hey Don, thanks for this! I realize this is a bit off topic from the OP but I figured while you and Oscar are on a roll I might pipe in with a question.

Mipmapping only helps if your renderer streams in textures based on distance (like Unreal or V-Ray). But KeyShot loads all textures into GPU memory at full res, so mipmapping by itself doesn’t lower VRAM usage. Without on-demand texture streaming? No real benefit.

Let’s say I wanted to build a material that I could use across various use cases. To copy your formatting:

Use Case	Material Setup
Wide shots/context scenes	“Basic” material, little to no texture maps
General purpose renders	“Regular” material, bump/roughness maps at reasonable scales
Closeups/detail shots	“Advanced” material, with full PBR maps and displacement if necessary

I ran a test to explore this concept and set these up as a manual LOD in a multi-material. I can see obvious performance differences in the samples/sec between the material types, as well as an increase in VRAM usage as I go from “basic” (2.7GB) to “advanced” (2.9GB). This is in line with what I expected.

In setting up the file, I started with building the “basic” material first before creating the other two, and noticed the VRAM usage go up from ~2.5 to ~2.7GB on the “basic” material as I added more and more textures to the inactive “regular” and “advanced” materials. Does KeyShot load some of the textures on inactive materials as well, or is this just some overhead in the program as the material graph gets more complicated?

My end goal would be to set up a few materials like this for use across all of our scenes, and I want to make sure I’m not shooting myself in the foot in the search for more performance.

Samples Setting – GPU Ignores It

The material “samples” setting only affects CPU rendering . On GPU , it’s effectively a dead slider doesn’t influence quality or noise reduction. Probably makes sense to disable or hide it in GPU mode for clarity.

+1, Would be great if this was greyed out in GPU mode (maybe with a hover tooltip that explains the slider is for CPU only). I think removing options entirely may lead to confusion.

[don.tuttle]

@calvin.henderson

Does KeyShot load some of the textures on inactive materials as well, or is this just some overhead in the program as the material graph gets more complicated?

Yes, the Multi-Material would load all of the textures even if the sub-material isn’t being used. I would simply have a second version of the texture and swap it (if necessary) using the “Replace and Retain Size”.

You guys are all in good shape, as is you have more RAM than I do. Seriously, don’t get hung up on this. That said, if you start running out of memory or your render hangs on the network, you know where to start investigating the issue.

[oscar.rottink]

Sorry @imauserwiththisname for hijacking your thread but love how much info is in here now. Would be nice if some of it also got copied in the manual.

@calvin.henderson nice question as well, while it would save memory not to include unused textures I can imagine this is done because it would pause the real time view since it needs to load the right textures in VRAM every time you switch the multi-materials.

If you still want to use that LOD/MipMap concept you could create a different scene and pack as ksp. Unpack it at a different place, use a batch tool to resize all textures and save the scene with something as lores suffix.

That uses the habit of KS to refresh all textures on load, still miss an option to refresh/update all textures while being inside KS. If I use Substance Painter I just close my scene and open it again, that’s the fast way of updating the used textures. Doesn’t win the beauty contest though

[don.tuttle]

@oscar.rottink The refresh textures should still be available in the library. See screenshot. LMK if you do not see it or if it’s broken.

Thanks!

[oscar.rottink]

@don.tuttle you made me happy there was something but unfortunately that was not what I meant I use Substance Painter a lot for packaging mock-ups so all textures are UV based and therefor custom and fit only one object.

I have now a box with 9 items which roughly uses 26 textures. If I change something in the textures and export them again, I need to refresh every single texture of every single material manually.

It would be nice if there was an option so it would automatically notice textures have changed, or a refresh button like in your example with the library. Since there is no such option the fastest way is to close KeyShot and just load the scene again, or maybe it also works if I load the same file again. But it feels a bit clumsy this is the way to refresh used textures.

[don.tuttle]

Thanks for the clarification. What you want can be hacked with a script. Below is a working proof of concept. That said, while functional it still needs some work because currently it only updates inactive material textures. I’d also like to add an automatic rename identical nodes and name unnamed nodes. Currently I have helper scripts for the naming.

If you’re interested in these scripts LMK. If I ever get the texture refresh working, I’ll follow up.

# AUTHOR LUX DT ChatGPT
# VERSION 2.2.0
# Refresh scene texture nodes for all **INACTIVE** materials only.
# ALL Material Shader Nodes MUST be named — and they MUST be named UNIQUELY FIRST!
# Known Limitation: Labels — when image textures are connected to Opacity via Shader Edges,the Alpha Mode may not update correctly due to caching or UI binding.


import lux

def force_texture_refresh(param):
    """
    Forces KeyShot to refresh a texture by toggling the path.
    """
    original_path = param.getValue()
    if original_path:
        dummy_path = original_path + "_temp"
        try:
            param.setValue(dummy_path)
        except:
            pass
        param.setValue(original_path)

def ensure_unique_node_names(graph):
    """
    Ensures all shader nodes in a graph have unique names to avoid conflicts.
    """
    seen = {}
    for node in graph.getNodes():
        name = node.getName()
        if name in seen:
            count = seen[name] + 1
            new_name = f"{name}_{count}"
            node.setName(new_name)
            seen[name] = count
            print(f"Renamed duplicate node '{name}' to '{new_name}'")
        else:
            seen[name] = 1

def convert_to_multimaterial_if_needed(material_name):
    """
    Converts a single material to a multimaterial and adds a clone sub-material.
    Returns the name of the new sub-material selected to avoid UI lock.
    """
    graph = lux.getMaterialGraph(material_name)
    if not graph:
        return None

    if not graph.isMultiMaterial():
        graph.setMultiMaterial(True)

    root = graph.getRoot()
    duplicate = graph.duplicateShaderTree(root)
    if duplicate:
        graph.setCurrentSubMaterial(duplicate)
        return duplicate.getName()
    return None

def deselect_active_material():
    """
    Applies a dummy material to force KeyShot to deselect the active one to avoid texture refresh lock.
    """
    dummy = lux.createMaterial("temp_unselect_material")
    if dummy:
        try:
            lux.applyMaterialToSelection(dummy)
        except:
            pass
        lux.deleteMaterial(dummy)

def refresh_texture_nodes(material_name):
    """
    Refresh all image texture nodes for a given material.
    """
    graph = lux.getMaterialGraph(material_name)
    if graph is None:
        print(f"Material graph not found for '{material_name}'.")
        return

    texture_nodes = graph.getNodesFromType(lux.SHADER_TYPE_TEXTURE_MAP)
    if not texture_nodes:
        print(f"No texture map nodes found in material '{material_name}'.")
        return

    ensure_unique_node_names(graph)

    for node in texture_nodes:
        param = node.getParameter("texture")
        if param:
            force_texture_refresh(param)
            print(f"Refreshed texture on node '{node.getName()}' with path: {param.getValue()}")

def refresh_all_scene_textures():
    """
    Refreshes texture nodes for all scene materials, avoiding active material lock.
    """
    try:
        lux.setCamera("Default Camera")
        deselect_active_material()
    except:
        pass

    materials = lux.getSceneMaterials()
    print(f"Found {len(materials)} materials.")

    for mat in materials:
        print(f"Processing material: {mat}")

        try:
            refresh_texture_nodes(mat)

            multi = lux.getMultiMaterial(mat)
            if multi:
                sub_materials = multi.getSubMaterials()
                for sub in sub_materials:
                    print(f" - Sub-material: {sub}")
                    refresh_texture_nodes(sub)
            else:
                selected = convert_to_multimaterial_if_needed(mat)
                if selected:
                    refresh_texture_nodes(selected)
        except Exception as e:
            print(f"Skipping material '{mat}' due to error: {e}")

refresh_all_scene_textures()

[oscar.rottink]

Cool! Must say I can do some JavaScript and PHP/MySQL but I’m actually pretty happy that’s a thing of the past for me It gets easier though now you can ask some AI for some help I noticed with a little private project. My Python knowledge is close to zero though but would love to get to know a bit more since so many software I use can use those scripts to replace tasks.

I think the general update/refresh would be useful to have inside KeyShot but I’ve no clue how many people actually create their own textures based on UVs since that makes it extra useful. If you use a lot of labels I think it can also save a lot of work.

And maybe it can be just a list of textures used with an exclamation mark if something needs a refresh (the way InDesign does it) placing little refresh icon behind it so you just have to check the list. I think that list can also serve a nice purpose to show the size of textures in pixels, bit-depth and the amount of VRAM they use. That would make it also easier for people to optimize their scene. Such a kind of file manager / overview would be really nice.

[matt.gerard]

we def could use a “Python for Creatives that don’t think like software engineers” class.